Mechanically supported design of self-stabilizing algorithms

Het schrijven van een programma is vaak veel gemakkelijker dan te bewijzen dat een programma doet wat het moet doen. Daarbij wordt onze samenleving steeds afhankelijker van computers; men denke daarbij aan complexe programmatuur die de verkeersleiding van treinen of vliegtuigen regelt, die de administratie van de eectenhandel bijhoudt of die besluit of de stormvloedkering al dan niet neergelaten moet worden. Om de kwaliteit van programmatuur te kunnen garanderen, wordt ze uitgebreid getest. Dit wordt meestal gedaan met de probeer-en-faal methode, waarbij een pro- gramma op testinvoer wordt losgelaten en er vervolgens wordt gekeken of het aan de verwachtingen van de programmeur en klant voldoet. Deze manier van testen elimi- neert helaas niet alle fouten. We horen dan ook vaak mensen over bugs in programma's praten. Softwarefabrikanten komen regelmatig met nieuwe versies van hun produkten die de bugs van de vorige versie niet meer bevatten. Dat klopt vaak wel, maar helaas is het eerder regel dan uitzondering dat de nieuwere versie nieuwe bugs bevat. Kortom, bugs lijken als een soort onvermijdbare erfenis in programma's voor te komen. Voor een programma zoals een tekstverwerking kunnen we best wel met een bug of twee leven, maar van een studenten-administratiesyteem verwachten we toch dat het pro- gramma niet onbedoeld met de cijfers van de studenten omgaat. We verwachten ook, om een paar andere voorbeelden te noemen, dat onze prive brieven die elektronisch via het Internet worden verzonden niet per ongeluk aan het verkeerde adres worden afgeleverd, of dat een elektronisch besturingsysteem van een vliegtuig niet plotseling weigert. Met de genoemde probeer-en-faal testmethode kunnen wij slechts constateren dat tijdens een test alles goed ging. Helaas is het veelal onmogelijk alle toestanden waarin een computersysteem zich kan bevinden na gaan met een test. Dat zou veel te veel tijd kosten of is soms zelfs theoretisch nietuitvoerbaar, nog daargelaten of het commercieel acceptabel zou zijn. Een andere methode die tot een betere softwarekwaliteit kan leiden is de volledig formele aanpak; hierbij is een programmeur verplicht om een wiskundig bewijs van de correctheid van zijn programma te leveren. Meestal wordt een programma hierbij ontworpen tegelijkertijd met het construeren van een bewijs dat het programma aan de specicatie voldoet. Er wordt gebruik gemaakt van een speciaal soort wiskunde (vaak programma-logica genoemd) voor het redeneren over eigenschappen van een pro- gramma. Met deze methode kan men bewijzen dat een programma qua ontwerp fout- loos is, zonder dat men het programma zelf hoeft te testen. Dit betekent nog niet dat in de praktijk het geproduceerde programma echt foutloos zal zijn, want het ontwerp is maar een van de vele stadia |alhoewel een van de belangrijkste| in het produceren van software. Wel kunnen wij zeggen dat het resultaat betrouwbaarder zal zijn. Net zoals dat wij fouten kunnen maken bij het schrijven van een programma, kun- nen wij helaas ook fouten maken bij het geven van een bewijs. Een gecompliceerd?Page 236 programma vraagt meestaal ook een gecompliceerd bewijs. De kans om fouten te maken zal toenemen, en het is niet onwaarschijnlijk dat een denkfout die gemaakt wordt bij het ontwerpen van een programma ook gemaakt wordt bij het construeren van een correctheidsbewijs voor dat programma. Parallel met het ontwikkelen van formele methoden, is ook de technologie om bewi- jzen te kunnen veri?eren met de computer ge?evolueerd. Deze technologie noemen we mechanisch vericatie en het computerprogramma die dat doet noemen we (niet echt passend) een stellingbewijzer. Een stellingbewijzer wordt gebaseerd op een handvol axiomas en bewijsregels. De consistentie en zinvolheid van deze axiomas en bewijs- regels zijn veelal al uitgebreid bestudeerd en er bestaat consensus over hun consis- tentie. Het bewijs van een nieuwe stelling kan alleen worden geconstrueerd door het herhaaldelijk toepassing van de bewijsregels, uitgaande van de axiomas. De juistheid van deze nieuwe stellingen wordt dus afgedwongen door de manier waarop ze wor- den gebouwd. In veel stellingbewijzers kan men ook nieuwe bewijsregels denieren in termen van reeds bestaande (primitieve) bewijsregels. Deze nieuwe stellingen en bewi- jstactieken zijn vaak krachtiger dan de ingebouwde en kunnen dus leiden tot kortere en meer inzichtelijke bewijzen. In dit proefschrift wordt speciaal aandacht besteed aan zogenaamde gedistribueerde programma's. Een gedistribueerd programma is een programma dat bestaat uit samen- werkende componenten |elke component heeft meestal een eigen processor. Zulke pro- gramma's worden heel veel gebruikt, bijvoorbeeld in het Internet waarbij computers uit de hele wereld in een groot elektronisch netwerk worden verbonden. Boodschappen van de ene computer moeten, via tussen-computers, worden verstuurd naar de bestem- mingscomputer. Op elk van deze tussen-computers draait een component van een routeringsprogramma. Deze routeringsprogramma's hebben kennis van (een gedeelte) van de structuur van het netwerk. Omdat het netwerk voortdurend van vorm veran- dert (er kunnen verbindingen bijkomen of wegvallen, en er kunnen tussen-computers aangezet en uitgezet worden) moeten deze computers het netwerk zelf gebruiken om samen uit te vinden hoe de globale structuur is. Zo'n routeringsprogramma is een voorbeeld van een gedistribueerd programma. Omdat het vaak om veel componenten gaat die over, tussen, met en door elkaar werken, is het redeneren over een gedistribueerd programma moeilijk. In dit proefschrift bestuderen we de programma-logica UNITY die speciaal ontworpen is omte redeneren over eigenschappen van gedistribueerde programma's [CM88]. UNITY is klein en sim- pel, en daarom aantrekkelijk. Toch is programma's ontwerpen met UNITY, in onze ervaring, vaak erg lastig. Er ontbreekt een systematische ontwerpmethodologie, en sommige ontwerptechnieken bleken niet ondersteund te (kunnen) worden. We hebben dus UNITY uitgebreid, vooral om technieken rond het opsplitsen van programma in parallel werkende componenten beter te ondersteunen. Er worden voorbeelden gegeven om te laten zien hoe we de specicatie van een probleem kunnen vereenvoudigen door een geschikte opsplitsing te kiezen. We besteden daarbij vooral aandacht aan zogenaamde zelf-stabiliserende, gedis- tribueerde programma's. Een zelf-stabiliserend programma is een programma dat het systeem weer in een gewenste toestand kan brengen als het daar, door een externe?Page 237 verstoring, uit geraakt is. Ook als er tijdens dit herstellen weer nieuwe verstoringen optreden is dat geen probleem voor dergelijke systemen. We hebben UNITY uitge- breid met een reeks van stellingen om over zulke programma's te kunen redeneren. We behandelen een groot voorbeeld, het zogenaamde Eerlijk en Herhaaldelijk Toepassing (EHT) programma. Het EHT programma is een gedistribueerd programma dat een bepaalde klasse van problemen zelf-stabiliserend kan oplossen (uitrekenen). Dit boek is uniek omdat het niet alleen over formele methoden of over het bewi- jzen van een of ander moeilijk programma gaat, maar omdat vrijwel alle resultaten mechanisch geverieerd zijn met een stellingbewijzer! Onze ervaring met mechanisch vericatie wordt ook in dit boek beschreven. Mensen die ook met mechanisch veri- catie van gedistribueerde programma's willen beginnen zullen veel onderwerpen in dit boek interessant vinden. Tot slot willen we benadrukken dat het beoefenen van formele methoden vereist dat programmeurs een goed ontwikkelde wiskundige handvaardigheid hebben. Het eectief opereren met een stellingbewijzer is tot nu toe, helaas, slechts voorbehouden aan een handjevol specialisten. Het is begrijpelijk dat de industrie twijfelt aan de economisch waarde van formele methoden. Toch zullen mensen vroeg of laat, naar mate wij steeds afhankelijker worden van computers, ontdekken hoe kwetsbaar ze zijn als er fouten in computers optreden. In de toekomst zullen mensen dus gedwongen zijn om naar stellingbewijzers te kijken. Investeren in de technologie van mechanisch vericatie en in het opleiden van 'formele' programmeurs, is daarom, naar onze mening, geen weg gegooide moeite.

The Analysis of Rank Fusion Techniques to Improve Query Relevance

Rank fusion meta-search engine algorithms can be used to merge web search results of multiple search engines. In this paper we introduce two variants of the Weighted Borda-Fuse algorithm. The first variant retrieves documents based on popularities of component engines. The second one is based on k user-defined toplist of component engines. In this research, experiments were performed on k={50,100,200} toplist with AND/OR combinations implemented on ‘UNIB Meta Fusion’ meta-search engine prototype which employed 3 out of 5 popular search engines. Both of our two algorithms outperformed other rank fusion algorithms (relevance score is upto 0.76 compare to Google that is 0.27, at P@10). The pseudo-relevance automatic judgement techniques involved are Reciprocal Rank, Borda Count, and Condorcet. The optimal setting was reached for queries with operator "AND" (degree 1) or "AND ... AND" (degree 2) with k=200. The ‘UNIB Meta Fusion’ meta-search engine system was built correctly

T3i: A Tool for Generating and Querying Test Suites for Java

T3i is an automated unit-testing tool to test Java classes. To expose interactions T3i generates test-cases in the form of sequences of calls to the methods of the target class. What separates it from other testing tools is that it treats test suites as first class objects and allows users to e.g. combine, query, and filter them. With these operations, the user can construct a test suite with specific properties. Queries can be used to check correctness properties. Hoare triples, LTL formulas, and algebraic equations can be queried. T3i can be used interactively, thus facilitating more exploratory testing, as well as through a script. The familiar Java syntax can be used to control it, or alternatively one can use the much lighter Groovy syntax

Formal design of self-stabilizing programs: Theory and examples

It is commonly realized that informal reasoning about distributed algorithms in general and self-stabilizing systems in particular is very error-prone. Formal method is considered as a promising solution, but is still in an immature state for the fact that formal proofs of even simple algorithms are tedious and difficult to follow. We believe that to make the method more appealing one should not only pay attention to 'theoretical' issues such as consistency and completeness, but also to the 'ergonomics' of the method. In this spirit, this paper proposes a number of new operators to model self-stabilization and a formalization of a number of useful design strategies. It is hoped that their use can improve the ease with which algorithmic reasoning is formally applied. Some examples showing how various laws are used will given in Part II

HLogo: a parallel Haskell variant of Netlogo

Agent-based Modeling (ABM) has become quite popular to the simulation community for its usability and wide area of applicability. However, speed is not usually a trait that ABM tools are characterized of attaining. This paper presents HLogo, a parallel variant of the NetLogo ABM framework, that seeks to increase the performance of ABM by utilizing Software Transactional Memory and multi-core CPUs, all the while maintaining the user friendliness of NetLogo. HLogo is implemented as a Domain Specific Language embedded in the functional language Haskell, which means that it also inherits Haskell,s features, such as its static typing. © Copyright 2016 by SCITEPRESS - Science and Technology Publications, Lda. All rights reserved

Wiki-MetaSemantik: une approche d'extension de requête dérivée de wikipedia basée sur les propriétés du réseau

International audienceThis paper discusses the use of Wikipedia for building semantic ontologies to do Query Expansion (QE) in order to improve the search results of search engines. In this technique, selecting related Wikipedia concepts becomes important. We propose the use of network properties (degree, closeness, and pageRank) to build an ontology graph of user query concepts which is derived directly from Wikipedia structures. The resulting expansion system is called Wiki-MetaSemantik. We tested this system against other online thesauruses and ontology based QE in both individual and meta-search engines setups. Despite that our system has to build a Wikipedia ontology graph in order to do its work, the technique turns out to work very fast (1:281) compared to another ontology QE baseline (Wikipedia Persian ontology QE). It has thus the potential to be utilized online. Furthermore, it shows significant improvement in accuracy. Wiki-MetaSemantik also shows better performance in a meta-search engine (MSE) set up rather than in an individual search engine set up.Cet article traite de l'utilisation de Wikipedia pour la construction de ontologies sémantique pour faire l'extension de requête (QE) afin d'améliorer les résultats de recherche des moteurs de recherche. Dans cette technique, la sélection des concepts de wikipedia connexes devient importante. Nous proposons l'utilisation de propriétés réseau (degré, proximité et pageRank) pour créer un graphique d'ontologie des concepts de requête utilisateur qui est dérivé directement de structures Wikipédia. Le système d'expansion résultant est appelé wiki-MetaSemantik. Nous avons testé ce système contre d'autres Thésaurus en ligne et l'ontologie basée qe dans les deux particuliers et Meta-Search Engines configurations. Malgré que notre système doit construire un graphe d'ontologie de wikipedia afin de faire son travail, la technique s'avère travailler très rapidement (1:281) par rapport à une autre ligne de base de qe d'ontologie (l'ontologie perse de wikipedia QE). Il a donc le potentiel d'être utilisé en ligne. En outre, il montre une amélioration significative de l'exactitude. Wiki-MetaSemantik montre également de meilleures performances dans un moteur de Meta-Search (MSE) mis en place plutôt que dans un moteur de recherche individuel mis en place

T3i: A Tool for Generating and Querying Test Suites for Java

T3i is an automated unit-testing tool to test Java classes. To expose interactions T3i generates test-cases in the form of sequences of calls to the methods of the target class. What separates it from other testing tools is that it treats test suites as first class objects and allows users to e.g. combine, query, and filter them. With these operations, the user can construct a test suite with specific properties. Queries can be used to check correctness properties. Hoare triples, LTL formulas, and algebraic equations can be queried. T3i can be used interactively, thus facilitating more exploratory testing, as well as through a script. The familiar Java syntax can be used to control it, or alternatively one can use the much lighter Groovy syntax

Reduce First, Debug Later

The delta debugging minimization algorithm ddmin provides an efficient procedure for the simplification of failing test-cases. Despite its contribution towards the automation of debugging, ddmin still requires a significant number of iterations to complete. The delta debugging (DD) search space can be narrowed down by providing the test-case circumstances that are most likely relevant to the occurred failure. This paper proposes a novel approach to the problem of failure simplification consisting of two consecutive phases: 1) failure reduction by rewriting (performed offline), and 2) DD invocation (performed online). In the best case scenario, the reduction phase may already deliver a simplified failure, otherwise, it potentially supplies DD with extra information about where to look for the failure. The proposed solution has been prototyped as a web application debugging tool, which was evaluated on a shopping cart web application - Flex Store. The evaluation shows an improvement of the DD execution time if the offline reduction over-approximates the failure